home *** CD-ROM | disk | FTP | other *** search
/ Almathera Ten Pack 3: CDPD 3 / Almathera Ten on Ten - Disc 3: CDPD3.iso / ab20 / ab20_archive / datacomm / xpr / xprkermit-1.111.lzh / ckwart.c < prev    next >
C/C++ Source or Header  |  1991-12-21  |  15KB  |  652 lines
  1. char *wartv = "Wart Version 2A(007) Aug 1990";
  2.  
  3. #ifdef MDEBUG
  4. /* Use the real ones in this module only */
  5. #ifdef malloc
  6. #undef malloc
  7. #endif /* malloc */
  8. #ifdef calloc
  9. #undef calloc
  10. #endif /* calloc */
  11. #ifdef realloc
  12. #undef realloc
  13. #endif /* realloc */
  14. #ifdef free
  15. #undef free
  16. #endif /* free */
  17. #endif /* MDEBUG */
  18.  
  19. /* W A R T */
  20.  
  21. /*
  22.  A small subset of "lex".
  23.  
  24.  Authors: Jeff Damens, Frank da Cruz,
  25.  Columbia University Center for Computing Activites.
  26.  First released November 1984.
  27.  Copyright (C) 1984, 1991,
  28.  Trustees of Columbia University in the City of New York.
  29.  Permission is granted to any individual or institution to use, copy, or
  30.  redistribute this software so long as it is not sold for profit, provided 
  31.  this copyright notice is retained. 
  32. */
  33.  
  34. /*
  35.  * input format is:
  36.  *  lines to be copied | %state <state names...>
  37.  *  %%
  38.  * <state> | <state,state,...> CHAR  { actions }
  39.  * ...
  40.  *  %%
  41.  */
  42.  
  43. #include "ckcdeb.h"            /* Includes */
  44.  
  45. /*
  46.  The following "CHAR" should be changed to "short", "int", or "long" if your
  47.  wart program will generate more than 127 states.  Since wart is used mainly
  48.  with C-Kermit, which has less than 50 states, "short" is adequate.  This 
  49.  keeps the program about 3K-4K smaller.
  50. */
  51.  
  52. #define TBL_TYPE "char"            /* C data type of state table */
  53.  
  54. #define C_L 014                /* Formfeed */
  55.  
  56. #define SEP 1                            /* Token types */
  57. #define LBRACK 2
  58. #define RBRACK 3
  59. #define WORD 4
  60. #define COMMA 5
  61.  
  62. /* Storage sizes */
  63.  
  64. #define MAXSTATES 50            /* max number of states */
  65. #define MAXWORD 50            /* max # of chars/word */
  66. #define SBYTES ((MAXSTATES+7)/8)    /* # of bytes for state bitmask */
  67.  
  68. /* Name of wart function in generated program */
  69.  
  70. #ifndef FNAME
  71. #define FNAME "wart"
  72. #endif
  73.  
  74. /* Structure for state information */
  75.  
  76. struct transx {
  77.     CHAR states[SBYTES];        /* included states */
  78.     int anyst;                /* true if this good from any state */
  79.     CHAR inchr;                /* input character */
  80.     int actno;                /* associated action */
  81.     struct transx *nxt;
  82. };                    /* next transition */
  83. typedef struct transx *trans;
  84.  
  85. /* Function prototypes */
  86.  
  87. _PROTOTYP( VOID setwstate, (int, trans) );
  88. _PROTOTYP( int teststate, (int, trans) );
  89. _PROTOTYP( trans rdinput, (FILE *, FILE *) );
  90. _PROTOTYP( VOID initial, (FILE *, FILE *) );
  91. _PROTOTYP( int isin, (char *, int) );
  92. _PROTOTYP( int isword, (int) );
  93. _PROTOTYP( VOID rdword, (FILE *, char *) );
  94. _PROTOTYP( VOID rdstates, (FILE *, FILE *) );
  95. _PROTOTYP( trans newtrans, (void) );
  96. _PROTOTYP( trans rdrules, (FILE *, FILE *) );
  97. _PROTOTYP( VOID statelist, (FILE *, trans) );
  98. _PROTOTYP( VOID copyact, (FILE *, FILE *, int) );
  99. _PROTOTYP( int faction, (trans, int, int) );
  100. _PROTOTYP( VOID emptytbl, (void) );
  101. _PROTOTYP( VOID addaction, (int, int, int) );
  102. _PROTOTYP( VOID writetbl, (FILE *) );
  103. _PROTOTYP( VOID warray, (FILE *, char *, int *, int, char *) );
  104. _PROTOTYP( VOID fatal, (char *) );
  105. _PROTOTYP( VOID prolog, (FILE *) );
  106. _PROTOTYP( VOID epilogue, (FILE *) );
  107. _PROTOTYP( VOID copyrest, (FILE *, FILE *) );
  108. _PROTOTYP( int gettoken, (FILE *) );
  109. _PROTOTYP( VOID rdcmnt, (FILE *) );
  110. _PROTOTYP( VOID clrhash, (void) );
  111. _PROTOTYP( int hash, (char *) );
  112. _PROTOTYP( VOID enter, (char *, int) );
  113. _PROTOTYP( int lkup, (char *) );
  114.  
  115. /* Variables and tables */
  116.  
  117. int lines, nstates, nacts;
  118.  
  119. char tokval[MAXWORD];
  120.  
  121. int tbl[MAXSTATES*128];
  122.  
  123. char *tbl_type = TBL_TYPE;
  124.  
  125. char *txt1 = "\n#define BEGIN state =\n\nint state = 0;\n\nint\n";
  126.  
  127. char *fname = FNAME;            /* Generated function name goes here */
  128.  
  129. /* rest of program... */
  130.  
  131. char *txt2 = "()\n\
  132. {\n\
  133.     int c,actno;\n\
  134.     extern ";
  135.  
  136. /* Data type of state table is inserted here (short or int) */
  137.  
  138. char *txt2a = " tbl[];\n    while (1) {\n    c = input();\n";
  139.  
  140. char *txt2b = "    if ((actno = tbl[c + state*128]) != -1)\n\
  141.         switch(actno) {\n";
  142.  
  143. /* this program's output goes here, followed by final text... */
  144.  
  145. char *txt3 = "\n        }\n    }\n}\n\n";
  146.  
  147.  
  148. /*
  149.  * turn on the bit associated with the given state
  150.  *
  151.  */
  152. VOID
  153. setwstate(state,t) int state; trans t; {
  154.     int idx,msk;
  155.     idx = state/8;            /* byte associated with state */
  156.     msk = 0x80 >> (state % 8);        /* bit mask for state */
  157.     t->states[idx] |= msk;
  158. }
  159.  
  160. /*
  161.  * see if the state is involved in the transition
  162.  *
  163.  */
  164. int
  165. teststate(state,t) int state; trans t; {
  166.     int idx,msk;
  167.     idx = state/8;
  168.     msk = 0x80 >> (state % 8);
  169.     return(t->states[idx] & msk);
  170. }
  171.  
  172.  
  173. /*
  174.  * read input from here...
  175.  *
  176.  */
  177.  
  178. trans
  179. rdinput(infp,outfp) FILE *infp,*outfp; {
  180.     trans x,rdrules();
  181.     lines = 1;                /* line counter */
  182.     nstates = 0;            /* no states */
  183.     nacts = 0;                /* no actions yet */
  184.     fprintf(outfp,"\n%c* WARNING -- This C source program generated by ",'/');
  185.     fprintf(outfp,"Wart preprocessor. */\n");
  186.     fprintf(outfp,"%c* Do not edit this file; edit the Wart-format ",'/');
  187.     fprintf(outfp,"source file instead, */\n");
  188.     fprintf(outfp,"%c* and then run it through Wart to produce a new ",'/');
  189.     fprintf(outfp,"C source file.     */\n\n");
  190.     fprintf(outfp,"%c* Wart Version Info: */\n",'/');
  191.     fprintf(outfp,"char *wartv = \"%s\";\n\n",wartv);
  192.  
  193.     initial(infp,outfp);        /* read state names, initial defs */
  194.     prolog(outfp);            /* write out our initial code */
  195.     x = rdrules(infp,outfp);        /* read rules */
  196.     epilogue(outfp);            /* write out epilogue code */
  197.     return(x);
  198. }
  199.  
  200.  
  201. /*
  202.  * initial - read initial definitions and state names.  Returns
  203.  * on EOF or %%.
  204.  *
  205.  */
  206. VOID
  207. initial(infp,outfp) FILE *infp, *outfp; {
  208.     int c;
  209.     char wordbuf[MAXWORD];
  210.     while ((c = getc(infp)) != EOF) {
  211.     if (c == '%') {
  212.         rdword(infp,wordbuf);
  213.         if (strcmp(wordbuf,"states") == 0)
  214.           rdstates(infp,outfp);
  215.         else if (strcmp(wordbuf,"%") == 0) return;
  216.         else fprintf(outfp,"%%%s",wordbuf);
  217.     }
  218.     else putc(c,outfp);
  219.     if (c == '\n') lines++;
  220.     }
  221. }
  222.  
  223. /*
  224.  * boolean function to tell if the given character can be part of
  225.  * a word.
  226.  *
  227.  */
  228. int
  229. isin(s,c) char *s; int c; {
  230.     for (; *s != '\0'; s++)
  231.       if (*s == c) return(1);
  232.     return(0);
  233. }
  234. int
  235. isword(c) int c; {
  236.     static char special[] = ".%_-$@";    /* these are allowable */
  237.     return(isalnum(c) || isin(special,c));
  238. }
  239.  
  240. /*
  241.  * read the next word into the given buffer.
  242.  *
  243.  */
  244. VOID
  245. rdword(fp,buf) FILE *fp; char *buf; {
  246.     int len = 0,c;
  247.     while (isword(c = getc(fp)) && ++len < MAXWORD) *buf++ = c;
  248.     *buf++ = '\0';            /* tie off word */
  249.     ungetc(c,fp);            /* put break char back */
  250. }
  251.  
  252. /*
  253.  * read state names, up to a newline.
  254.  *
  255.  */
  256. VOID
  257. rdstates(fp,ofp) FILE *fp,*ofp; {
  258.     int c;
  259.     char wordbuf[MAXWORD];
  260.     while ((c = getc(fp)) != EOF && c != '\n')   {
  261.     if (isspace(c) || c == C_L) continue;    /* skip whitespace */
  262.     ungetc(c,fp);            /* put char back */
  263.     rdword(fp,wordbuf);        /* read the whole word */
  264.     enter(wordbuf,++nstates);    /* put into symbol tbl */
  265.     fprintf(ofp,"#define %s %d\n",wordbuf,nstates);
  266.     }
  267.     lines++;
  268. }
  269.         
  270. /*
  271.  * allocate a new, empty transition node
  272.  *
  273.  */
  274. trans
  275. newtrans() {
  276.     trans new;
  277.     int i;
  278.     new = (trans) malloc(sizeof (struct transx));
  279.     for (i=0; i<SBYTES; i++) new->states[i] = 0;
  280.     new->anyst = 0;
  281.     new->nxt = NULL;
  282.     return(new);
  283. }
  284.  
  285.  
  286. /*
  287.  * read all the rules.
  288.  *
  289.  */
  290.  
  291. trans
  292. rdrules(fp,out) FILE *fp,*out; {
  293.     trans head,cur,prev;
  294.     int curtok;
  295.     head = cur = prev = NULL;
  296.     while ((curtok = gettoken(fp)) != SEP) 
  297.  
  298.       switch(curtok) {
  299.     case LBRACK:
  300.       if (cur == NULL)
  301.         cur = newtrans();
  302.       else
  303.         fatal("duplicate state list");
  304.       statelist(fp,cur);        /* set states */
  305.       continue;            /* prepare to read char */
  306.       
  307.     case WORD:
  308.       if (strlen(tokval) != 1)
  309.         fatal("multiple chars in state");
  310.       if (cur == NULL) {
  311.           cur = newtrans();
  312.           cur->anyst = 1;
  313.       }
  314.       cur->actno = ++nacts;
  315.       cur->inchr = tokval[0];
  316.       if (head == NULL)
  317.         head = cur;
  318.       else
  319.         prev->nxt = cur;
  320.       prev = cur;
  321.       cur = NULL;
  322.       copyact(fp,out,nacts);
  323.       break; 
  324.     default: fatal("bad input format");
  325.       }
  326.     return(head);
  327. }
  328.  
  329. /*
  330.  * read a list of (comma-separated) states, set them in the
  331.  * given transition.
  332.  *
  333.  */
  334. VOID
  335. statelist(fp,t) FILE *fp; trans t; {
  336.     int curtok,sval;
  337.     curtok = COMMA;
  338.     while (curtok != RBRACK) {
  339.     if (curtok != COMMA) fatal("missing comma");
  340.     if ((curtok = gettoken(fp)) != WORD) fatal("missing state name");
  341.         if ((sval = lkup(tokval)) == -1) {
  342.         fprintf(stderr,"state %s undefined\n",tokval);
  343.         fatal("undefined state");
  344.     }
  345.         setwstate(sval,t);    
  346.     curtok = gettoken(fp);
  347.     }
  348. }
  349.  
  350. /*
  351.  * copy an action from the input to the output file
  352.  *
  353.  */
  354. VOID
  355. copyact(inp,outp,actno) FILE *inp,*outp; int actno; {
  356.     int c,bcnt;
  357.     fprintf(outp,"case %d:\n",actno);
  358.     while (c = getc(inp), (isspace(c) || c == C_L))
  359.       if (c == '\n') lines++;
  360.     if (c == '{') {
  361.     bcnt = 1;
  362.     fputs("    {",outp);
  363.     while (bcnt > 0 && (c = getc(inp)) != EOF) {
  364.         if (c == '{') bcnt++;
  365.         else if (c == '}') bcnt--;
  366.         else if (c == '\n') lines++;
  367.         putc(c,outp);
  368.     }
  369.     if (bcnt > 0) fatal("action doesn't end");
  370.     } else {
  371.     while (c != '\n' && c != EOF) {
  372.         putc(c,outp);
  373.         c = getc(inp);
  374.     }
  375.     lines++;
  376.     }
  377.     fprintf(outp,"\n    break;\n");
  378. }
  379.  
  380. /*
  381.  * find the action associated with a given character and state.
  382.  * returns -1 if one can't be found.
  383.  *
  384.  */
  385. int
  386. faction(hd,state,chr) trans hd; int state,chr; {
  387.     while (hd != NULL) {
  388.     if (hd->anyst || teststate(state,hd))
  389.       if (hd->inchr == '.' || hd->inchr == chr) return(hd->actno);
  390.     hd = hd->nxt;
  391.     }
  392.     return(-1);
  393. }
  394.  
  395. /*
  396.  * empty the table...
  397.  *
  398.  */
  399. VOID
  400. emptytbl() {
  401.     int i;
  402.     for (i=0; i<nstates*128; i++) tbl[i] = -1;
  403. }
  404.  
  405. /*
  406.  * add the specified action to the output for the given state and chr.
  407.  *
  408.  */
  409. VOID
  410. addaction(act,state,chr) int act,state,chr; {
  411.     tbl[state*128 + chr] = act;
  412. }
  413.  
  414. VOID
  415. writetbl(fp) FILE *fp; {
  416.     warray(fp,"tbl",tbl,128*(nstates+1),TBL_TYPE);
  417. }
  418.  
  419.  
  420. /*
  421.  * write an array to the output file, given its name and size.
  422.  *
  423.  */
  424. VOID
  425. warray(fp,nam,cont,siz,typ) FILE *fp; char *nam; int cont[],siz; char *typ; {
  426.     int i;
  427.     fprintf(fp,"%s %s[] = {\n",typ,nam);
  428.     for (i = 0; i < siz; ) {
  429.     fprintf(fp,"%2d, ",cont[i]);
  430.     if ((++i % 16) == 0) putc('\n',fp);
  431.     }
  432.     fprintf(fp,"};\n");
  433. }
  434.  
  435. VOID
  436. main(argc,argv) int argc; char *argv[]; {
  437.     trans head;
  438.     int state,c;
  439.     FILE *infile,*outfile;
  440.  
  441.     if (argc > 1) {
  442.     if ((infile = fopen(argv[1],"r")) == NULL) {
  443.         fprintf(stderr,"Can't open %s\n",argv[1]);
  444.         fatal("unreadable input file");
  445.     }
  446.     } else infile = stdin;
  447.  
  448.     if (argc > 2) {
  449.     if ((outfile = fopen(argv[2],"w")) == NULL) {
  450.         fprintf(stderr,"Can't write to %s\n",argv[2]);
  451.         fatal("bad output file");
  452.     }
  453.     } else outfile = stdout;
  454.  
  455.     clrhash();                /* empty hash table */
  456.     head = rdinput(infile,outfile);    /* read input file */
  457.     emptytbl();                /* empty our tables */
  458.     for (state = 0; state <= nstates; state++)
  459.       for (c = 1; c < 128; c++)        /* find actions, */
  460.     addaction(faction(head,state,c),state,c); /* add to tbl */
  461.     writetbl(outfile);
  462.     copyrest(infile,outfile);
  463.     printf("%d states, %d actions\n",nstates,nacts);
  464.     exit(GOOD_EXIT);
  465. }
  466.  
  467.  
  468. /*
  469.  * fatal error handler
  470.  *
  471.  */
  472.  
  473. VOID
  474. fatal(msg) char *msg; {
  475.     fprintf(stderr,"error in line %d: %s\n",lines,msg);
  476.     exit(BAD_EXIT);
  477. }
  478.  
  479. VOID
  480. prolog(outfp) FILE *outfp; {
  481.     int c;
  482.     while ((c = *txt1++)     != '\0') putc(c,outfp);
  483.     while ((c = *fname++)    != '\0') putc(c,outfp);
  484.     while ((c = *txt2++)     != '\0') putc(c,outfp);
  485.     while ((c = *tbl_type++) != '\0') putc(c,outfp);
  486.     while ((c = *txt2a++)    != '\0') putc(c,outfp);
  487.     while ((c = *txt2b++)    != '\0') putc(c,outfp);
  488. }
  489.  
  490. VOID
  491. epilogue(outfp) FILE *outfp; {
  492.     int c;
  493.     while ((c = *txt3++) != '\0') putc(c,outfp);
  494. }
  495.  
  496. VOID
  497. copyrest(in,out) FILE *in,*out; {
  498.     int c;
  499.     while ((c = getc(in)) != EOF) putc(c,out);
  500. }
  501.  
  502. /*
  503.  * gettoken - returns token type of next token, sets tokval
  504.  * to the string value of the token if appropriate.
  505.  *
  506.  */
  507.  
  508. int
  509. gettoken(fp) FILE *fp; {
  510.     int c;
  511.     while (1) {                /* loop if reading comments... */
  512.     do {
  513.         c = getc(fp);
  514.         if (c == '\n') lines++;
  515.     } while ((isspace(c) || c == C_L)); /* skip whitespace */
  516.     switch(c) {
  517.       case EOF:
  518.         return(SEP);
  519.       case '%':
  520.         if ((c = getc(fp)) == '%') return(SEP);
  521.         tokval[0] = '%';
  522.         tokval[1] = c;
  523.         rdword(fp,tokval+2);
  524.         return(WORD);
  525.       case '<':
  526.         return(LBRACK);
  527.       case '>':
  528.         return(RBRACK);
  529.       case ',':
  530.         return(COMMA);
  531.       case '/':
  532.         if ((c = getc(fp)) == '*') {
  533.         rdcmnt(fp);        /* skip over the comment */
  534.         continue;
  535.         } else {            /* and keep looping */
  536.         ungetc(c,fp);        /* put this back into input */
  537.         c = '/';        /* put character back, fall thru */
  538.         }
  539.  
  540.       default:
  541.         if (isword(c)) {
  542.         ungetc(c,fp);
  543.         rdword(fp,tokval);
  544.         return(WORD);
  545.         } else fatal("Invalid character in input");
  546.     }
  547.     }
  548. }
  549.  
  550. /*
  551.  * skip over a comment
  552.  *
  553.  */
  554.  
  555. VOID
  556. rdcmnt(fp) FILE *fp; {
  557.     int c,star,prcnt;
  558.     prcnt = star = 0;            /* no star seen yet */
  559.     while (!((c = getc(fp)) == '/' && star)) {
  560.     if (c == EOF || (prcnt && c == '%')) fatal("Unterminated comment");
  561.     prcnt = (c == '%');
  562.     star = (c == '*');
  563.     if (c == '\n') lines++;
  564.     }
  565. }
  566.  
  567. /*
  568.  * symbol table management for wart
  569.  *
  570.  * entry points:
  571.  *   clrhash - empty hash table.
  572.  *   enter - enter a name into the symbol table
  573.  *   lkup - find a name's value in the symbol table.
  574.  *
  575.  */
  576.  
  577. #define HASHSIZE 101            /* # of entries in hash table */
  578.  
  579. struct sym {
  580.     char *name;                /* symbol name */
  581.     int val;                /* value */
  582.     struct sym *hnxt;            /* next on collision chain */
  583. } *htab[HASHSIZE];            /* the hash table */
  584.  
  585. /*
  586.  * empty the hash table before using it...
  587.  *
  588.  */
  589. VOID
  590. clrhash() {
  591.     int i;
  592.     for (i=0; i<HASHSIZE; i++) htab[i] = NULL;
  593. }
  594.  
  595. /*
  596.  * compute the value of the hash for a symbol
  597.  *
  598.  */
  599. int
  600. hash(name) char *name; {
  601.     int sum;
  602.     for (sum = 0; *name != '\0'; name++) sum += (sum + *name);
  603.     sum %= HASHSIZE;            /* take sum mod hashsize */
  604.     if (sum < 0) sum += HASHSIZE;    /* disallow negative hash value */
  605.     return(sum);
  606. }
  607.  
  608. /*
  609.  * make a private copy of a string...
  610.  *
  611.  */
  612. static char*
  613. copy(s) char *s; {
  614.     char *new;
  615.     new = (char *) malloc(strlen(s) + 1);
  616.     strcpy(new,s);
  617.     return(new);
  618. }
  619.  
  620. /*
  621.  * enter state name into the hash table
  622.  *
  623.  */
  624. VOID
  625. enter(name,svalue) char *name; int svalue; {
  626.     int h;
  627.     struct sym *cur;
  628.     if (lkup(name) != -1) {
  629.     fprintf(stderr,"state %s appears twice...\n");
  630.     exit(BAD_EXIT);
  631.     }
  632.     h = hash(name);
  633.     cur = (struct sym *)malloc(sizeof (struct sym));
  634.     cur->name = copy(name);
  635.     cur->val = svalue;
  636.     cur->hnxt = htab[h];
  637.     htab[h] = cur;
  638. }
  639.  
  640. /*
  641.  * find name in the symbol table, return its value.  Returns -1
  642.  * if not found.
  643.  *
  644.  */
  645. int
  646. lkup(name) char *name; {
  647.     struct sym *cur;
  648.     for (cur = htab[hash(name)]; cur != NULL; cur = cur->hnxt)
  649.       if (strcmp(cur->name,name) == 0) return(cur->val);
  650.     return(-1);
  651. }
  652.